ജാവാസ്ക്രിപ്റ്റ് എക്കോസിസ്റ്റം അൺലോക്ക് ചെയ്യുന്നു: ടൈപ്പ്സ്ക്രിപ്റ്റ് ഡിക്ലറേഷൻ ഫയലുകളിലേക്ക് ഒരു ആഴത്തിലുള്ള വിശകലനം

ജാവാസ്ക്രിപ്റ്റിൻ്റെ ഡൈനാമിക് ലോകത്തേക്ക് സ്റ്റാറ്റിക് ടൈപ്പിംഗ് കൊണ്ടുവന്ന് ടൈപ്പ്സ്ക്രിപ്റ്റ് ആധുനിക വെബ് ഡെവലപ്മെൻ്റിൽ വിപ്ലവം സൃഷ്ടിച്ചു. ഈ ടൈപ്പ് സുരക്ഷ വലിയ പ്രയോജനങ്ങൾ നൽകുന്നു: കംപൈൽ സമയത്ത് പിശകുകൾ കണ്ടെത്തുക, ശക്തമായ എഡിറ്റർ ഓട്ടോ കംപ്ലീഷൻ പ്രവർത്തനക്ഷമമാക്കുക, വലിയ കോഡ്ബേസുകൾ കൂടുതൽ പരിപാലിക്കാൻ എളുപ്പമാക്കുക. എന്നിരുന്നാലും, നിലവിലുള്ള ജാവാസ്ക്രിപ്റ്റ് ലൈബ്രറികളുടെ വലിയ എക്കോസിസ്റ്റം ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുമ്പോൾ ഒരു വലിയ വെല്ലുവിളി ഉണ്ടാവാറുണ്ട് - അതിൽ മിക്കവയും ടൈപ്പ്സ്ക്രിപ്റ്റിൽ എഴുതിയതല്ല. ടൈപ്പ് ചെയ്യാത്ത ഒരു ജാവാസ്ക്രിപ്റ്റ് ലൈബ്രറിയിൽ നിന്നുള്ള രൂപങ്ങൾ, ഫംഗ്ഷനുകൾ, വേരിയബിളുകൾ എന്നിവയെ നമ്മുടെ കർശനമായി ടൈപ്പ് ചെയ്ത ടൈപ്പ്സ്ക്രിപ്റ്റ് കോഡ് എങ്ങനെ മനസ്സിലാക്കും?

ടൈപ്പ്സ്ക്രിപ്റ്റ് ഡിക്ലറേഷൻ ഫയലുകളിലാണ് ഇതിനുള്ള ഉത്തരം ഒളിഞ്ഞരിക്കുന്നത്. .d.ts എക്സ്റ്റൻഷൻ ഉപയോഗിച്ച് തിരിച്ചറിയാൻ കഴിയുന്ന ഈ ഫയലുകൾ, ടൈപ്പ്സ്ക്രിപ്റ്റിനും ജാവാസ്ക്രിപ്റ്റ് ലോകത്തിനുമിടയിലുള്ള പ്രധാന പാലമാണ്. അവ ഒരു ബ്ലൂപ്രിൻ്റായി അല്ലെങ്കിൽ ഒരു API കരാറായി പ്രവർത്തിക്കുന്നു, ഏതെങ്കിലും തേർഡ്-പാർട്ടി ലൈബ്രറിയുടെ യഥാർത്ഥ കോഡ് ഇല്ലാതെ തന്നെ അതിൻ്റെ ടൈപ്പുകളെ വിവരിക്കുന്നു. ഈ സമഗ്രമായ ഗൈഡിൽ, നിങ്ങളുടെ ടൈപ്പ്സ്ക്രിപ്റ്റ് പ്രോജക്റ്റുകളിലെ ഏതൊരു ജാവാസ്ക്രിപ്റ്റ് ലൈബ്രറിക്കുമുള്ള ടൈപ്പ് ഡെഫിനിഷനുകൾ ആത്മവിശ്വാസത്തോടെ കൈകാര്യം ചെയ്യാൻ നിങ്ങൾ അറിയേണ്ടതെല്ലാം ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും.

എന്താണ് ടൈപ്പ്സ്ക്രിപ്റ്റ് ഡിക്ലറേഷൻ ഫയലുകൾ?

നിങ്ങൾ ഒരു വ്യത്യസ്ത ഭാഷ മാത്രം സംസാരിക്കുന്ന ഒരു കോൺട്രാക്ടറെ നിയമിച്ചുവെന്ന് സങ്കൽപ്പിക്കുക. അവരുമായി ഫലപ്രദമായി പ്രവർത്തിക്കാൻ, നിങ്ങൾക്ക് ഒരു ട്രാൻസ്ലേറ്ററോ അല്ലെങ്കിൽ നിങ്ങൾക്കും അവർക്കും മനസ്സിലാക്കാവുന്ന ഭാഷയിലുള്ള വിശദമായ നിർദ്ദേശങ്ങളോ ആവശ്യമാണ്. ഒരു ഡിക്ലറേഷൻ ഫയൽ ടൈപ്പ്സ്ക്രിപ്റ്റ് കംപൈലറിന് (കോൺട്രാക്ടർ) ഈ കൃത്യമായ ഉദ്ദേശ്യം നിറവേറ്റുന്നു.

ഒരു .d.ts ഫയലിൽ ടൈപ്പ് വിവരങ്ങൾ മാത്രമേ അടങ്ങിയിട്ടുള്ളൂ. അതിൽ താഴെ പറയുന്നവ ഉൾപ്പെടുന്നു:

• ഫംഗ്ഷനുകളുടെയും രീതികളുടെയും സിഗ്നേച്ചറുകൾ (പാരാമീറ്റർ ടൈപ്പുകൾ, റിട്ടേൺ ടൈപ്പുകൾ).
• വേരിയബിളുകൾക്കും അവയുടെ ടൈപ്പുകൾക്കുമുള്ള ഡെഫിനിഷനുകൾ.
• സങ്കീർണ്ണമായ ഒബ്ജക്റ്റുകൾക്കുള്ള ഇൻ്റർഫേസുകളും ടൈപ്പ് അപരനാമങ്ങളും.
• ക്ലാസ് ഡെഫിനിഷനുകൾ, അവയുടെ പ്രോപ്പർട്ടികളും രീതികളും ഉൾപ്പെടെ.
• Namespace, മൊഡ്യൂൾ ഘടനകൾ.

പ്രധാനമായി, ഈ ഫയലുകളിൽ എക്സിക്യൂട്ടബിൾ കോഡ് അടങ്ങിയിട്ടില്ല. അവ സ്റ്റാറ്റിക് വിശകലനത്തിന് മാത്രമുള്ളതാണ്. നിങ്ങൾ Lodash പോലുള്ള ഒരു ജാവാസ്ക്രിപ്റ്റ് ലൈബ്രറി നിങ്ങളുടെ ടൈപ്പ്സ്ക്രിപ്റ്റ് പ്രോജക്റ്റിലേക്ക് ഇമ്പോർട്ട് ചെയ്യുമ്പോൾ, കംപൈലർ അതിന് അനുയോജ്യമായ ഒരു ഡിക്ലറേഷൻ ഫയലിനായി തിരയുന്നു. ഒരെണ്ണം കണ്ടെത്തിയാൽ, നിങ്ങളുടെ കോഡ് സാധൂകരിക്കാനും ഇൻ്റലിജൻ്റ് ഓട്ടോ കംപ്ലീഷൻ നൽകാനും നിങ്ങൾ ലൈബ്രറി ശരിയായി ഉപയോഗിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കാനും ഇതിന് കഴിയും. ഇല്ലെങ്കിൽ, ഇത് ഒരു പിശക് ഉയർത്തും: Could not find a declaration file for module 'lodash'.

പ്രൊഫഷണൽ ഡെവലപ്മെൻ്റിന് ഡിക്ലറേഷൻ ഫയലുകൾ ഒഴിവാക്കാനാവാത്തത് എന്തുകൊണ്ട്

ഒരു ടൈപ്പ്സ്ക്രിപ്റ്റ് പ്രോജക്റ്റിൽ ശരിയായ ടൈപ്പ് ഡെഫിനിഷനുകളില്ലാത്ത ജാവാസ്ക്രിപ്റ്റ് ലൈബ്രറികൾ ഉപയോഗിക്കുന്നത് ടൈപ്പ്സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നതിനുള്ള കാരണം തന്നെ ഇല്ലാതാക്കുന്നു. ജനപ്രിയ യൂട്ടിലിറ്റി ലൈബ്രറിയായ Lodash ഉപയോഗിച്ച് ഒരു ലളിതമായ സാഹചര്യം പരിഗണിക്കാം.

ടൈപ്പ് ഡെഫിനിഷനുകളില്ലാത്ത ലോകം

ഒരു ഡിക്ലറേഷൻ ഫയലില്ലാതെ, lodash എന്താണെന്നോ അതിൽ എന്താണുള്ളതെന്നോ ടൈപ്പ്സ്ക്രിപ്റ്റിന് അറിയില്ല. കോഡ് കംപൈൽ ചെയ്യാൻ പോലും, ഇത് ഉപയോഗിക്കാൻ നിങ്ങൾ പ്രേരിപ്പിച്ചേക്കാം:

const _: any = require('lodash'); const users = [{ 'user': 'barney' }, { 'user': 'fred' }]; // Autocomplete? No help here. // Type checking? No. Is 'username' the correct property? // The compiler allows this, but it might fail at runtime. _.find(users, { username: 'fred' });

ഈ സാഹചര്യത്തിൽ, _ വേരിയബിൾ any ടൈപ്പ് ആണ്. ഇത് ടൈപ്പ്സ്ക്രിപ്റ്റിനോട് പറയുന്നത് പോലെയാണ്, "ഈ വേരിയബിളുമായി ബന്ധപ്പെട്ട ഒന്നും പരിശോധിക്കേണ്ടതില്ല." നിങ്ങൾക്ക് എല്ലാ ആനുകൂല്യങ്ങളും നഷ്ടപ്പെടും: ഓട്ടോ കംപ്ലീഷൻ ഇല്ല, ആർഗ്യുമെൻ്റുകളിൽ ടൈപ്പ് പരിശോധനയില്ല, റിട്ടേൺ ടൈപ്പിനെക്കുറിച്ച് ഉറപ്പില്ല. ഇത് റൺടൈം പിശകുകൾക്കുള്ള ഒരു പ്രധാന കാരണമാണ്.

ടൈപ്പ് ഡെഫിനിഷനുകളുള്ള ലോകം

ഇപ്പോൾ, ആവശ്യമായ ഡിക്ലറേഷൻ ഫയൽ നൽകുമ്പോൾ എന്ത് സംഭവിക്കുമെന്ന് നോക്കാം. ടൈപ്പുകൾ ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം (അത് ഞങ്ങൾ അടുത്തതായി കവർ ചെയ്യും), അനുഭവം മാറുന്നു:

import _ from 'lodash'; interface User { user: string; active?: boolean; } const users: User[] = [{ 'user': 'barney' }, { 'user': 'fred' }]; // 1. Editor provides autocompletion for 'find' and other lodash functions. // 2. Hovering over 'find' shows its full signature and documentation. // 3. TypeScript sees that `users` is an array of `User` objects. // 4. TypeScript knows the predicate for `find` on `User[]` should involve `user` or `active`. // CORRECT: TypeScript is happy. const fred = _.find(users, { user: 'fred' }); // ERROR: TypeScript catches the mistake! // Property 'username' does not exist on type 'User'. const betty = _.find(users, { username: 'betty' });

വ്യത്യാസം വളരെ വലുതാണ്. ടൂളിംഗ് വഴി മികച്ച ഡെവലപ്പർ അനുഭവം, എല്ലാ ടൈപ്പ് സുരക്ഷയും, പിശകുകൾ കുറയ്ക്കാനുള്ള സാധ്യതയുമുണ്ട്. ടൈപ്പ്സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള പ്രൊഫഷണൽ നിലവാരമാണിത്.

ടൈപ്പ് ഡെഫിനിഷനുകൾ കണ്ടെത്താനുള്ള ശ്രേണി

അപ്പോൾ, നിങ്ങളുടെ ഇഷ്ടപ്പെട്ട ലൈബ്രറികൾക്കായി ഈ മാന്ത്രിക .d.ts ഫയലുകൾ എങ്ങനെ നേടാം? മിക്ക സാഹചര്യങ്ങളെയും ഉൾക്കൊള്ളുന്ന ഒരു പ്രക്രിയയുണ്ട്.

ഘട്ടം 1: ലൈബ്രറി അതിൻ്റേതായ ടൈപ്പുകൾ നൽകുന്നുണ്ടോയെന്ന് പരിശോധിക്കുക

ഒരു ലൈബ്രറി ടൈപ്പ്സ്ക്രിപ്റ്റിൽ എഴുതുകയോ അല്ലെങ്കിൽ അതിൻ്റെ മെയിൻ്റനർമാർ അതേ പാക്കേജിനുള്ളിൽ ഔദ്യോഗിക ഡിക്ലറേഷൻ ഫയലുകൾ നൽകുകയോ ചെയ്യുമ്പോൾ ഉള്ള സാഹചര്യമാണ് ഏറ്റവും നല്ലത്. ആധുനികവും നല്ല രീതിയിൽ പരിപാലിക്കപ്പെടുന്നതുമായ പ്രോജക്റ്റുകൾക്ക് ഇത് കൂടുതൽ സാധാരണമായിക്കൊണ്ടിരിക്കുകയാണ്.

എങ്ങനെ പരിശോധിക്കാം:

1. usual: npm install axios എന്നപോലെ ലൈബ്രറി ഇൻസ്റ്റാൾ ചെയ്യുക
2. node_modules/axios-ലെ ലൈബ്രറിയുടെ ഫോൾഡറിനുള്ളിൽ നോക്കുക. നിങ്ങൾക്ക് എന്തെങ്കിലും .d.ts ഫയലുകൾ കാണാൻ കഴിയുന്നുണ്ടോ?
3. ലൈബ്രറിയുടെ package.json ഫയലിൽ "types" അല്ലെങ്കിൽ "typings" ഫീൽഡ് പരിശോധിക്കുക. ഈ ഫീൽഡ് പ്രധാന ഡിക്ലറേഷൻ ഫയലിലേക്ക് നേരിട്ട് പോയിൻ്റ് ചെയ്യുന്നു. ഉദാഹരണത്തിന്, Axios-ൻ്റെ package.json-ൽ അടങ്ങിയിരിക്കുന്നു: "types": "index.d.ts".

ഈ നിബന്ധനകൾ പാലിക്കുകയാണെങ്കിൽ, നിങ്ങൾ പൂർത്തിയാക്കി! ടൈപ്പ്സ്ക്രിപ്റ്റ് ഈ ടൈപ്പുകൾ സ്വയമേവ കണ്ടെത്തി ഉപയോഗിക്കും. കൂടുതൽ പ്രവർത്തനമൊന്നും ആവശ്യമില്ല.

ഘട്ടം 2: ഡെഫിനിറ്റിലിടൈപ്പ്ഡ് പ്രോജക്റ്റ് (@types)

സ്വന്തമായി ടൈപ്പുകൾ നൽകാത്ത ആയിരക്കണക്കിന് ജാവാസ്ക്രിപ്റ്റ് ലൈബ്രറികൾക്കായി, ആഗോള ടൈപ്പ്സ്ക്രിപ്റ്റ് കമ്മ്യൂണിറ്റി ഒരു വലിയ റിസോഴ്സ് ഉണ്ടാക്കിയിട്ടുണ്ട്: ഡെഫിനിറ്റിലിടൈപ്പ്ഡ്.

ഡെഫിനിറ്റിലിടൈപ്പ്ഡ് എന്നത് GitHub-ലെ ഒരു കേന്ദ്രീകൃതവും കമ്മ്യൂണിറ്റി-മാനേജ് ചെയ്യുന്നതുമായ ശേഖരണമാണ്, ഇത് ധാരാളം ജാവാസ്ക്രിപ്റ്റ് പാക്കേജുകൾക്കായി ഉയർന്ന നിലവാരമുള്ള ഡിക്ലറേഷൻ ഫയലുകൾ ഹോസ്റ്റ് ചെയ്യുന്നു. ഈ ഡെഫിനിഷനുകൾ @types സ്കോപ്പിന് കീഴിൽ npm രജിസ്ട്രിയിലേക്ക് പ്രസിദ്ധീകരിക്കുന്നു.

ഇത് എങ്ങനെ ഉപയോഗിക്കാം:

lodash പോലുള്ള ഒരു ലൈബ്രറി അതിൻ്റേതായ ടൈപ്പുകൾ നൽകുന്നില്ലെങ്കിൽ, അതിന് അനുയോജ്യമായ @types പാക്കേജ് ഒരു ഡെവലപ്മെൻ്റ് ഡിപെൻഡൻസിയായി ഇൻസ്റ്റാൾ ചെയ്യുക:

npm install --save-dev @types/lodash

പേരിടൽ രീതി ലളിതവും പ്രവചിക്കാൻ കഴിയുന്നതുമാണ്: package-name എന്ന് പേരുള്ള ഒരു പാക്കേജിന്, അതിൻ്റെ ടൈപ്പുകൾ മിക്കവാറും എല്ലായ്പ്പോഴും @types/package-name-ൽ ആയിരിക്കും. നിങ്ങൾക്ക് npm വെബ്സൈറ്റിലോ ഡെഫിനിറ്റിലിടൈപ്പ്ഡ് ശേഖരണത്തിലോ ലഭ്യമായ ടൈപ്പുകൾക്കായി തിരയാവുന്നതാണ്.

എന്തുകൊണ്ട് --save-dev? ഡെവലപ്മെൻ്റ്, കംപൈലേഷൻ സമയത്ത് മാത്രമേ ഡിക്ലറേഷൻ ഫയലുകൾ ആവശ്യമുള്ളൂ. അവയിൽ റൺടൈം കോഡുകളൊന്നും അടങ്ങിയിട്ടില്ല, അതിനാൽ അവ നിങ്ങളുടെ പ്രൊഡക്ഷൻ ബണ്ടിലിൽ ഉൾപ്പെടുത്തരുത്. അവയെ devDependency ആയി ഇൻസ്റ്റാൾ ചെയ്യുന്നത് ഈ വേർതിരിവ് ഉറപ്പാക്കുന്നു.

ഘട്ടം 3: ടൈപ്പുകളൊന്നും നിലവിലില്ലെങ്കിൽ - നിങ്ങളുടേതായെഴുതുക

ടൈപ്പുകൾ നൽകാത്തതും ഡെഫിനിറ്റിലിടൈപ്പ്ഡിൽ ഇല്ലാത്തതുമായ പഴയതോ, പ്രചാരമില്ലാത്തതോ, ഇൻ്റേണൽ പ്രൈവറ്റ് ലൈബ്രറിയോ ആണ് നിങ്ങൾ ഉപയോഗിക്കുന്നതെങ്കിൽ എന്തുചെയ്യും? ഈ സാഹചര്യത്തിൽ, നിങ്ങൾ നിങ്ങളുടെ കൈകൾ മടക്കി കുത്തി സ്വന്തമായി ഒരു ഡിക്ലറേഷൻ ഫയൽ ഉണ്ടാക്കേണ്ടതുണ്ട്. ഇത് പേടി തോന്നുന്ന ഒന്നായി തോന്നാമെങ്കിലും, നിങ്ങൾക്ക് ലളിതമായി ആരംഭിച്ച് ആവശ്യമനുസരിച്ച് കൂടുതൽ വിശദാംശങ്ങൾ ചേർക്കാവുന്നതാണ്.

ദ്രുത പരിഹാരം: ഷോർട്ട്ഹാൻഡ് ആംബിയൻ്റ് മൊഡ്യൂൾ ഡിക്ലറേഷൻ

ചില സമയങ്ങളിൽ, ശരിയായ ടൈപ്പിംഗ് തന്ത്രം കണ്ടെത്തുന്നതിന് നിങ്ങളുടെ പ്രോജക്റ്റ് പിശകുകളില്ലാതെ കംപൈൽ ചെയ്താൽ മതിയാകും. നിങ്ങളുടെ പ്രോജക്റ്റിൽ ഒരു ഫയൽ ഉണ്ടാക്കുക (ഉദാഹരണത്തിന്, declarations.d.ts അല്ലെങ്കിൽ types/global.d.ts) എന്നിട്ട് ഒരു ഷോർട്ട്ഹാൻഡ് ഡിക്ലറേഷൻ ചേർക്കുക:

// in a .d.ts file declare module 'some-untyped-library';

ഇത് ടൈപ്പ്സ്ക്രിപ്റ്റിനോട് പറയുന്നു, "വിശ്വസിക്കൂ, 'some-untyped-library' എന്ന് പേരുള്ള ഒരു മൊഡ്യൂൾ ഉണ്ട്. അതിൽ നിന്ന് ഇമ്പോർട്ട് ചെയ്യുന്നതെല്ലാം any ടൈപ്പായി കണക്കാക്കുക." ഇത് കംപൈലർ പിശക് ഇല്ലാതാക്കുന്നു, പക്ഷേ നമ്മൾ ചർച്ച ചെയ്തതുപോലെ, അത് ആ ലൈബ്രറിക്കുള്ള എല്ലാ ടൈപ്പ് സുരക്ഷയും ഇല്ലാതാക്കുന്നു. ഇതൊരു താൽക്കാലിക പരിഹാരമാണ്, ദീർഘകാലത്തേക്കുള്ള പരിഹാരമല്ല.

ഒരു അടിസ്ഥാന കസ്റ്റം ഡിക്ലറേഷൻ ഫയൽ ഉണ്ടാക്കുന്നു

ലൈബ്രറിയുടെ നിങ്ങൾ ഉപയോഗിക്കുന്ന ഭാഗങ്ങൾക്കായി ടൈപ്പുകൾ നിർവചിക്കാൻ തുടങ്ങുന്നതാണ് നല്ലൊരു സമീപനം. `string-utils` എന്ന് പേരുള്ള ഒരു ലളിതമായ ലൈബ്രറിയിൽ നിന്ന് ഒരൊറ്റ ഫംഗ്ഷൻ എക്സ്പോർട്ട് ചെയ്യുന്നു എന്ന് കരുതുക.

// In node_modules/string-utils/index.js module.exports.capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);

ഞങ്ങൾക്ക് ഒരു string-utils.d.ts ഫയൽ, ഞങ്ങളുടെ പ്രോജക്റ്റിൻ്റെ റൂട്ടിലുള്ള ഒരു ഡെഡിക്കേറ്റഡ് `types` ഡയറക്ടറിയിൽ ഉണ്ടാക്കാം.

// In my-project/types/string-utils.d.ts declare module 'string-utils' { export function capitalize(str: string): string; // You could add other function definitions here as you use them // export function slugify(str: string): string; }

ഇപ്പോൾ, ഞങ്ങളുടെ കസ്റ്റം ടൈപ്പ് ഡെഫിനിഷനുകൾ എവിടെ കണ്ടെത്തണമെന്ന് ടൈപ്പ്സ്ക്രിപ്റ്റിനോട് പറയേണ്ടതുണ്ട്. ഇത് tsconfig.json-ൽ ഞങ്ങൾ ചെയ്യുന്നു:

{ "compilerOptions": { // ... other options "baseUrl": ".", "paths": { "*": ["types/*"] } } }

ഈ സജ്ജീകരണത്തിലൂടെ, നിങ്ങൾ import { capitalize } from 'string-utils' ചെയ്യുമ്പോൾ, ടൈപ്പ്സ്ക്രിപ്റ്റ് നിങ്ങളുടെ കസ്റ്റം ഡിക്ലറേഷൻ ഫയൽ കണ്ടെത്തി നിങ്ങൾ നിർവചിച്ച ടൈപ്പ് സുരക്ഷ നൽകും. ലൈബ്രറിയുടെ കൂടുതൽ ഫീച്ചറുകൾ ഉപയോഗിക്കുമ്പോൾ നിങ്ങൾക്ക് ക്രമേണ ഈ ഫയൽ നിർമ്മിക്കാൻ കഴിയും.

ആഴത്തിലേക്ക്: ഡിക്ലറേഷൻ ഫയലുകൾ രചിക്കുന്നു

ഡിക്ലറേഷൻ ഫയലുകൾ എഴുതുമ്പോളോ വായിക്കുമ്പോളോ നിങ്ങൾ കണ്ടുമുട്ടുന്ന കൂടുതൽ വിപുലമായ ആശയങ്ങൾ നമുക്ക് പര്യവേക്ഷണം ചെയ്യാം.

വ്യത്യസ്ത തരത്തിലുള്ള എക്സ്പോർട്ടുകൾ പ്രഖ്യാപിക്കുന്നു

ജാവാസ്ക്രിപ്റ്റ് മൊഡ്യൂളുകൾക്ക് വിവിധ രീതികളിൽ കാര്യങ്ങൾ എക്സ്പോർട്ട് ചെയ്യാൻ കഴിയും. നിങ്ങളുടെ ഡിക്ലറേഷൻ ഫയൽ ലൈബ്രറിയുടെ എക്സ്പോർട്ട് ഘടനയുമായി പൊരുത്തപ്പെടണം.

• പേരുള്ള എക്സ്പോർട്ടുകൾ: ഇത് ഏറ്റവും സാധാരണമാണ്. `export function capitalize(...)` എന്നതിലൂടെ നമ്മൾ ഇത് മുകളിൽ കണ്ടു. നിങ്ങൾക്ക് കോൺസ്റ്റൻ്റുകൾ, ഇൻ്റർഫേസുകൾ, ക്ലാസുകൾ എന്നിവയും എക്സ്പോർട്ട് ചെയ്യാവുന്നതാണ്.

declare module 'my-lib' { export const version: string; export interface Options { retries: number; } export function doSomething(options: Options): Promise; }

• ഡിഫോൾട്ട് എക്സ്പോർട്ട്: export default ഉപയോഗിക്കുന്ന ലൈബ്രറികൾക്കായി.

declare module 'my-default-lib' { // For a function default export export default function myCoolFunction(): void; // For an object default export // const myLib = { name: 'lib', version: '1.0' }; // export default myLib; }

• UMD ഗ്ലോബലുകൾ: <script> ടാഗ് വഴി ബ്രൗസറുകളിൽ പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ള പഴയ ലൈബ്രറികൾക്കായി, അവ പലപ്പോഴും ഗ്ലോബൽ `window` ഒബ്ജക്റ്റിലേക്ക് സ്വയം അറ്റാച്ച് ചെയ്യുന്നു. നിങ്ങൾക്ക് ഈ ഗ്ലോബൽ വേരിയബിളുകൾ പ്രഖ്യാപിക്കാൻ കഴിയും.

// Declares a global variable '$' of a certain type declare var $: JQueryStatic;

• `export =` and `import = require()`: ഈ വാക്യഘടന പഴയ CommonJS മൊഡ്യൂളുകൾക്ക് വേണ്ടിയുള്ളതാണ്, അത് `module.exports = ...` ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു ലൈബ്രറി `module.exports = myClass;` ചെയ്യുന്നു എന്ന് കരുതുക.

// in my-class.d.ts declare class MyClass { constructor(name: string); } export = MyClass; // in your app.ts import MyClass = require('my-class'); const instance = new MyClass('test');

ആധുനിക ES മൊഡ്യൂളുകളിൽ ഇത് സാധാരണയായി കാണാറില്ലെങ്കിലും, ഇപ്പോഴും വ്യാപകമായി ഉപയോഗിക്കുന്ന പല പഴയ Node.js പാക്കേജുകളുമായുള്ള അനുയോജ്യതയ്ക്ക് ഇത് നിർണായകമാണ്.

മൊഡ്യൂൾ ഓഗ്മെൻ്റേഷൻ: നിലവിലുള്ള ടൈപ്പുകൾ വികസിപ്പിക്കുന്നു

ഏറ്റവും ശക്തമായ സവിശേഷതകളിലൊന്നാണ് മൊഡ്യൂൾ ഓഗ്മെൻ്റേഷൻ (ഡിക്ലറേഷൻ മെർജിംഗ് എന്നും അറിയപ്പെടുന്നു). മറ്റൊരു പാക്കേജിൻ്റെ ഡിക്ലറേഷൻ ഫയലിൽ നിർവചിച്ചിട്ടുള്ള നിലവിലുള്ള ഇൻ്റർഫേസുകളിലേക്ക് പ്രോപ്പർട്ടികൾ ചേർക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. Express അല്ലെങ്കിൽ Fastify പോലുള്ള ഒരു പ്ലഗിൻ ആർക്കിടെക്ചറുള്ള ലൈബ്രറികൾക്ക് ഇത് വളരെ ഉപയോഗപ്രദമാണ്.

Express-ൽ ഒരു മിഡിൽവെയർ ഉപയോഗിക്കുന്നു എന്ന് കരുതുക, അത് `Request` ഒബ്ജക്റ്റിലേക്ക് ഒരു `user` പ്രോപ്പർട്ടി ചേർക്കുന്നു. ഓഗ്മെൻ്റേഷനില്ലാതെ, `Request`-ൽ `user` നിലവിലില്ലെന്ന് ടൈപ്പ്സ്ക്രിപ്റ്റ് പരാതിപ്പെടും.

ഈ പുതിയ പ്രോപ്പർട്ടിയെക്കുറിച്ച് നിങ്ങൾക്ക് ടൈപ്പ്സ്ക്രിപ്റ്റിനോട് എങ്ങനെ പറയാമെന്ന് ഇതാ:

// in your types/express.d.ts file // We must import the original type to augment it import { UserProfile } from './auth'; // Assuming you have a UserProfile type // Tell TypeScript we're augmenting the 'express-serve-static-core' module declare module 'express-serve-static-core' { // Target the 'Request' interface inside that module interface Request { // Add our custom property user?: UserProfile; } }

ഇപ്പോൾ, നിങ്ങളുടെ ആപ്ലിക്കേഷനിലുടനീളം, Express `Request` ഒബ്ജക്റ്റ് ഓപ്ഷണലായ `user` പ്രോപ്പർട്ടി ഉപയോഗിച്ച് ശരിയായി ടൈപ്പ് ചെയ്യപ്പെടും, കൂടാതെ നിങ്ങൾക്ക് പൂർണ്ണമായ ടൈപ്പ് സുരക്ഷയും ഓട്ടോ കംപ്ലീഷനും ലഭിക്കും.

ട്രിപ്പിൾ-സ്ലാഷ് ഡയറക്റ്റീവുകൾ

ചില സമയങ്ങളിൽ .d.ts ഫയലുകളുടെ മുകളിൽ മൂന്ന് സ്ലാഷുകളിൽ (///) ആരംഭിക്കുന്ന കമൻ്റുകൾ നിങ്ങൾ കണ്ടേക്കാം. ഇവ ട്രിപ്പിൾ-സ്ലാഷ് ഡയറക്റ്റീവുകളാണ്, അത് കംപൈലർ നിർദ്ദേശങ്ങളായി പ്രവർത്തിക്കുന്നു.

• /// <reference types="..." />: ഇത് ഏറ്റവും സാധാരണമായ ഒന്നാണ്. ഇത് മറ്റൊരു പാക്കേജിൻ്റെ ടൈപ്പ് ഡെഫിനിഷനുകളെ ഒരു ഡിപെൻഡൻസിയായി വ്യക്തമായി ഉൾക്കൊള്ളുന്നു. ഉദാഹരണത്തിന്, ഒരു WebdriverIO പ്ലഗിനുള്ള ടൈപ്പുകളിൽ /// <reference types="webdriverio" /> ഉൾപ്പെട്ടേക്കാം, കാരണം അതിൻ്റെ ടൈപ്പുകൾ WebdriverIO ടൈപ്പുകളെ ആശ്രയിച്ചിരിക്കുന്നു.
• /// <reference path="..." />: ഒരേ പ്രോജക്റ്റിനുള്ളിലെ മറ്റൊരു ഫയലിനെ ആശ്രയിക്കുന്നു എന്ന് പറയാൻ ഇത് ഉപയോഗിക്കുന്നു. ഇതൊരു പഴയ വാക്യഘടനയാണ്, ES മൊഡ്യൂൾ ഇമ്പോർട്ടുകൾ ഇതിനെ വലിയ രീതിയിൽ മാറ്റിസ്ഥാപിച്ചു.

ഡിക്ലറേഷൻ ഫയലുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള മികച്ച രീതികൾ

1. നൽകിയിട്ടുള്ള ടൈപ്പുകൾ തിരഞ്ഞെടുക്കുക: ലൈബ്രറികൾക്കിടയിൽ തിരഞ്ഞെടുക്കുമ്പോൾ, ടൈപ്പ്സ്ക്രിപ്റ്റിൽ എഴുതിയതോ അതിൻ്റേതായ ഔദ്യോഗിക ടൈപ്പ് ഡെഫിനിഷനുകൾ നൽകുന്നതോ ആയ ലൈബ്രറികൾ തിരഞ്ഞെടുക്കുക. ഇത് ടൈപ്പ്സ്ക്രിപ്റ്റ് എക്കോസിസ്റ്റത്തോടുള്ള പ്രതിബദ്ധതയെ സൂചിപ്പിക്കുന്നു.
2. devDependencies-ൽ @types സൂക്ഷിക്കുക: എല്ലായ്പ്പോഴും @types പാക്കേജുകൾ --save-dev അല്ലെങ്കിൽ -D ഉപയോഗിച്ച് ഇൻസ്റ്റാൾ ചെയ്യുക. നിങ്ങളുടെ പ്രൊഡക്ഷൻ കോഡിന് അവ ആവശ്യമില്ല.
3. Align Versions: ലൈബ്രറി പതിപ്പും അതിൻ്റെ @types പതിപ്പും തമ്മിലുള്ള പൊരുത്തക്കേടാണ് പിശകുകൾ ഉണ്ടാകാനുള്ള ഒരു പ്രധാന കാരണം. ഒരു ലൈബ്രറിയിലെ പ്രധാന പതിപ്പ് (ഉദാഹരണത്തിന്, v2-ൽ നിന്ന് v3-ലേക്ക്) അതിൻ്റെ API-യിൽ മാറ്റങ്ങൾ വരുത്തിയേക്കാം, അത് @types പാക്കേജിൽ പ്രതിഫലിക്കണം. അവയെ സമന്വയിപ്പിച്ച് നിലനിർത്താൻ ശ്രമിക്കുക.
4. Control-നുള്ള tsconfig.json ഉപയോഗിക്കുക: നിങ്ങളുടെ tsconfig.json-ലെ typeRoots, types കംപൈലർ ഓപ്ഷനുകൾ ടൈപ്പ്സ്ക്രിപ്റ്റ് എവിടെയാണ് ഡിക്ലറേഷൻ ഫയലുകൾ തിരയേണ്ടതെന്ന് നിങ്ങൾക്ക് നിയന്ത്രിക്കാൻ കഴിയും. typeRoots കംപൈലറോട് ഏതൊക്കെ ഫോൾഡറുകളാണ് പരിശോധിക്കേണ്ടതെന്ന് പറയുന്നു (സ്ഥിരമായി, അത് ./node_modules/@types ആണ്), കൂടാതെ types ഏത് ടൈപ്പ് പാക്കേജുകളാണ് ഉൾപ്പെടുത്തേണ്ടതെന്ന് വ്യക്തമായി ലിസ്റ്റ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു.
5. തിരികെ സംഭാവന ചെയ്യുക: അതില്ലാത്ത ഒരു ലൈബ്രറിക്കായി നിങ്ങൾ ഒരു സമഗ്രമായ ഡിക്ലറേഷൻ ഫയൽ എഴുതുകയാണെങ്കിൽ, അത് ഡെഫിനിറ്റിലിടൈപ്പ്ഡ് പ്രോജക്റ്റിലേക്ക് സംഭാവന ചെയ്യാൻ ശ്രമിക്കുക. ആഗോള ഡെവലപ്പർ കമ്മ്യൂണിറ്റിക്ക് തിരികെ നൽകാനും ആയിരക്കണക്കിന് മറ്റുള്ളവരെ സഹായിക്കാനുമുള്ള മികച്ച മാർഗമാണിത്.

ഉപസംഹാരം: ടൈപ്പ് സുരക്ഷയുടെ മറഞ്ഞിരിക്കുന്ന ഹീറോകൾ

ജാവാസ്ക്രിപ്റ്റിൻ്റെ വിശാലമായ ലോകത്തെ ശക്തമായതും ടൈപ്പ് സുരക്ഷയുള്ളതുമായ ഡെവലപ്മെൻ്റ് എൻവയോൺമെൻ്റിലേക്ക് തടസ്സമില്ലാതെ സംയോജിപ്പിക്കാൻ സാധ്യമാക്കുന്ന മറഞ്ഞിരിക്കുന്ന ഹീറോകളാണ് ടൈപ്പ്സ്ക്രിപ്റ്റ് ഡിക്ലറേഷൻ ഫയലുകൾ. അവ നമ്മുടെ ടൂളുകൾക്ക് ശക്തി നൽകുകയും എണ്ണമറ്റ ബഗുകൾ തടയുകയും നമ്മുടെ കോഡ്ബേസുകൾ കൂടുതൽ സ്ഥിരതയുള്ളതും സ്വയം രേഖപ്പെടുത്തുന്നതുമാക്കുകയും ചെയ്യുന്നു.

.d.ts ഫയലുകൾ കണ്ടെത്താനും ഉപയോഗിക്കാനും സ്വന്തമായി ഉണ്ടാക്കാനും പഠിക്കുന്നതിലൂടെ, നിങ്ങൾ ഒരു കംപൈലർ പിശക് പരിഹരിക്കുക മാത്രമല്ല ചെയ്യുന്നത് - നിങ്ങളുടെ മുഴുവൻ ഡെവലപ്മെൻ്റ് വർക്ക്ഫ്ലോയും ഉയർത്തുകയാണ്. നിങ്ങൾ ടൈപ്പ്സ്ക്രിപ്റ്റിൻ്റെയും ജാവാസ്ക്രിപ്റ്റ് ലൈബ്രറികളുടെ സമ്പന്നമായ എക്കോസിസ്റ്റത്തിൻ്റെയും പൂർണ്ണമായ സാധ്യതകൾ അൺലോക്ക് ചെയ്യുന്നു, ഇത് ആഗോള പ്രേക്ഷകർക്കായി മികച്ചതും വിശ്വസനീയവുമായ സോഫ്റ്റ്വെയറുകൾക്ക് കാരണമാകുന്ന ശക്തമായ ഒരു കൂട്ടുകെട്ട് സൃഷ്ടിക്കുന്നു.